home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / linux / nfs_fs.h < prev    next >
C/C++ Source or Header  |  2005-10-13  |  23KB  |  783 lines
  1. /*
  2.  *  linux/include/linux/nfs_fs.h
  3.  *
  4.  *  Copyright (C) 1992  Rick Sladkey
  5.  *
  6.  *  OS-specific nfs filesystem definitions and declarations
  7.  */
  8.  
  9. #ifndef _LINUX_NFS_FS_H
  10. #define _LINUX_NFS_FS_H
  11.  
  12. #include <linux/config.h>
  13. #include <linux/in.h>
  14. #include <linux/mm.h>
  15. #include <linux/pagemap.h>
  16. #include <linux/rwsem.h>
  17. #include <linux/wait.h>
  18. #include <linux/uio.h>
  19.  
  20. #include <linux/nfs_fs_sb.h>
  21.  
  22. #include <linux/sunrpc/debug.h>
  23. #include <linux/sunrpc/auth.h>
  24. #include <linux/sunrpc/clnt.h>
  25.  
  26. #include <linux/nfs.h>
  27. #include <linux/nfs2.h>
  28. #include <linux/nfs3.h>
  29. #include <linux/nfs4.h>
  30. #include <linux/nfs_xdr.h>
  31. #include <linux/rwsem.h>
  32. #include <linux/workqueue.h>
  33. #include <linux/mempool.h>
  34.  
  35. /*
  36.  * Enable debugging support for nfs client.
  37.  * Requires RPC_DEBUG.
  38.  */
  39. #ifdef RPC_DEBUG
  40. # define NFS_DEBUG
  41. #endif
  42.  
  43. #define NFS_MAX_FILE_IO_BUFFER_SIZE    32768
  44. #define NFS_DEF_FILE_IO_BUFFER_SIZE    4096
  45.  
  46. /*
  47.  * The upper limit on timeouts for the exponential backoff algorithm.
  48.  */
  49. #define NFS_WRITEBACK_DELAY        (5*HZ)
  50. #define NFS_WRITEBACK_LOCKDELAY        (60*HZ)
  51. #define NFS_COMMIT_DELAY        (5*HZ)
  52.  
  53. /*
  54.  * superblock magic number for NFS
  55.  */
  56. #define NFS_SUPER_MAGIC            0x6969
  57.  
  58. /*
  59.  * These are the default flags for swap requests
  60.  */
  61. #define NFS_RPC_SWAPFLAGS        (RPC_TASK_SWAPPER|RPC_TASK_ROOTCREDS)
  62.  
  63. #define NFS_RW_SYNC        0x0001    /* O_SYNC handling */
  64. #define NFS_RW_SWAP        0x0002    /* This is a swap request */
  65.  
  66. /*
  67.  * When flushing a cluster of dirty pages, there can be different
  68.  * strategies:
  69.  */
  70. #define FLUSH_AGING        0    /* only flush old buffers */
  71. #define FLUSH_SYNC        1    /* file being synced, or contention */
  72. #define FLUSH_WAIT        2    /* wait for completion */
  73. #define FLUSH_STABLE        4    /* commit to stable storage */
  74. #define FLUSH_LOWPRI        8    /* low priority background flush */
  75. #define FLUSH_HIGHPRI        16    /* high priority memory reclaim flush */
  76.  
  77. #ifdef __KERNEL__
  78.  
  79. /*
  80.  * NFSv3/v4 Access mode cache entry
  81.  */
  82. struct nfs_access_entry {
  83.     unsigned long        jiffies;
  84.     struct rpc_cred *    cred;
  85.     int            mask;
  86. };
  87.  
  88. struct nfs4_state;
  89. struct nfs_open_context {
  90.     atomic_t count;
  91.     struct dentry *dentry;
  92.     struct rpc_cred *cred;
  93.     struct nfs4_state *state;
  94.     fl_owner_t lockowner;
  95.     int mode;
  96.     int error;
  97.  
  98.     struct list_head list;
  99.     wait_queue_head_t waitq;
  100. };
  101.  
  102. /*
  103.  * NFSv4 delegation
  104.  */
  105. struct nfs_delegation;
  106.  
  107. /*
  108.  * nfs fs inode data in memory
  109.  */
  110. struct nfs_inode {
  111.     /*
  112.      * The 64bit 'inode number'
  113.      */
  114.     __u64 fileid;
  115.  
  116.     /*
  117.      * NFS file handle
  118.      */
  119.     struct nfs_fh        fh;
  120.  
  121.     /*
  122.      * Various flags
  123.      */
  124.     unsigned int        flags;
  125.  
  126.     /*
  127.      * read_cache_jiffies is when we started read-caching this inode,
  128.      * and read_cache_mtime is the mtime of the inode at that time.
  129.      * attrtimeo is for how long the cached information is assumed
  130.      * to be valid. A successful attribute revalidation doubles
  131.      * attrtimeo (up to acregmax/acdirmax), a failure resets it to
  132.      * acregmin/acdirmin.
  133.      *
  134.      * We need to revalidate the cached attrs for this inode if
  135.      *
  136.      *    jiffies - read_cache_jiffies > attrtimeo
  137.      *
  138.      * and invalidate any cached data/flush out any dirty pages if
  139.      * we find that
  140.      *
  141.      *    mtime != read_cache_mtime
  142.      */
  143.     unsigned long        readdir_timestamp;
  144.     unsigned long        read_cache_jiffies;
  145.     unsigned long        attrtimeo;
  146.     unsigned long        attrtimeo_timestamp;
  147.     __u64            change_attr;        /* v4 only */
  148.  
  149.     /* "Generation counter" for the attribute cache. This is
  150.      * bumped whenever we update the metadata on the
  151.      * server.
  152.      */
  153.     unsigned long        cache_change_attribute;
  154.     /*
  155.      * Counter indicating the number of outstanding requests that
  156.      * will cause a file data update.
  157.      */
  158.     atomic_t        data_updates;
  159.  
  160.     struct nfs_access_entry    cache_access;
  161.  
  162.     /*
  163.      * This is the cookie verifier used for NFSv3 readdir
  164.      * operations
  165.      */
  166.     __u32            cookieverf[2];
  167.  
  168.     /*
  169.      * This is the list of dirty unwritten pages.
  170.      */
  171.     spinlock_t        req_lock;
  172.     struct list_head    dirty;
  173.     struct list_head    commit;
  174.     struct radix_tree_root    nfs_page_tree;
  175.  
  176.     unsigned int        ndirty,
  177.                 ncommit,
  178.                 npages;
  179.  
  180.     /* Open contexts for shared mmap writes */
  181.     struct list_head    open_files;
  182.  
  183.     wait_queue_head_t    nfs_i_wait;
  184.  
  185. #ifdef CONFIG_NFS_V4
  186.         /* NFSv4 state */
  187.     struct list_head    open_states;
  188.     struct nfs_delegation    *delegation;
  189.     int             delegation_state;
  190.     struct rw_semaphore    rwsem;
  191. #endif /* CONFIG_NFS_V4*/
  192.  
  193.     struct inode        vfs_inode;
  194. };
  195.  
  196. /*
  197.  * Legal inode flag values
  198.  */
  199. #define NFS_INO_STALE        0x0001        /* possible stale inode */
  200. #define NFS_INO_ADVISE_RDPLUS   0x0002          /* advise readdirplus */
  201. #define NFS_INO_REVALIDATING    0x0004        /* revalidating attrs */
  202. #define NFS_INO_INVALID_ATTR    0x0008        /* cached attrs are invalid */
  203. #define NFS_INO_INVALID_DATA    0x0010        /* cached data is invalid */
  204. #define NFS_INO_INVALID_ATIME    0x0020        /* cached atime is invalid */
  205. #define NFS_INO_INVALID_ACCESS    0x0040        /* cached access cred invalid */
  206.  
  207. static inline struct nfs_inode *NFS_I(struct inode *inode)
  208. {
  209.     return container_of(inode, struct nfs_inode, vfs_inode);
  210. }
  211. #define NFS_SB(s)        ((struct nfs_server *)(s->s_fs_info))
  212.  
  213. #define NFS_FH(inode)            (&NFS_I(inode)->fh)
  214. #define NFS_SERVER(inode)        (NFS_SB(inode->i_sb))
  215. #define NFS_CLIENT(inode)        (NFS_SERVER(inode)->client)
  216. #define NFS_PROTO(inode)        (NFS_SERVER(inode)->rpc_ops)
  217. #define NFS_ADDR(inode)            (RPC_PEERADDR(NFS_CLIENT(inode)))
  218. #define NFS_COOKIEVERF(inode)        (NFS_I(inode)->cookieverf)
  219. #define NFS_READTIME(inode)        (NFS_I(inode)->read_cache_jiffies)
  220. #define NFS_CHANGE_ATTR(inode)        (NFS_I(inode)->change_attr)
  221. #define NFS_ATTRTIMEO(inode)        (NFS_I(inode)->attrtimeo)
  222. #define NFS_MINATTRTIMEO(inode) \
  223.     (S_ISDIR(inode->i_mode)? NFS_SERVER(inode)->acdirmin \
  224.                    : NFS_SERVER(inode)->acregmin)
  225. #define NFS_MAXATTRTIMEO(inode) \
  226.     (S_ISDIR(inode->i_mode)? NFS_SERVER(inode)->acdirmax \
  227.                    : NFS_SERVER(inode)->acregmax)
  228. #define NFS_ATTRTIMEO_UPDATE(inode)    (NFS_I(inode)->attrtimeo_timestamp)
  229.  
  230. #define NFS_FLAGS(inode)        (NFS_I(inode)->flags)
  231. #define NFS_REVALIDATING(inode)        (NFS_FLAGS(inode) & NFS_INO_REVALIDATING)
  232. #define NFS_STALE(inode)        (NFS_FLAGS(inode) & NFS_INO_STALE)
  233.  
  234. #define NFS_FILEID(inode)        (NFS_I(inode)->fileid)
  235.  
  236. static inline int nfs_caches_unstable(struct inode *inode)
  237. {
  238.     return atomic_read(&NFS_I(inode)->data_updates) != 0;
  239. }
  240.  
  241. static inline void NFS_CACHEINV(struct inode *inode)
  242. {
  243.     if (!nfs_caches_unstable(inode))
  244.         NFS_FLAGS(inode) |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS;
  245. }
  246.  
  247. static inline int nfs_server_capable(struct inode *inode, int cap)
  248. {
  249.     return NFS_SERVER(inode)->caps & cap;
  250. }
  251.  
  252. static inline int NFS_USE_READDIRPLUS(struct inode *inode)
  253. {
  254.     return NFS_FLAGS(inode) & NFS_INO_ADVISE_RDPLUS;
  255. }
  256.  
  257. /**
  258.  * nfs_save_change_attribute - Returns the inode attribute change cookie
  259.  * @inode - pointer to inode
  260.  * The "change attribute" is updated every time we finish an operation
  261.  * that will result in a metadata change on the server.
  262.  */
  263. static inline long nfs_save_change_attribute(struct inode *inode)
  264. {
  265.     return NFS_I(inode)->cache_change_attribute;
  266. }
  267.  
  268. /**
  269.  * nfs_verify_change_attribute - Detects NFS inode cache updates
  270.  * @inode - pointer to inode
  271.  * @chattr - previously saved change attribute
  272.  * Return "false" if metadata has been updated (or is in the process of
  273.  * being updated) since the change attribute was saved.
  274.  */
  275. static inline int nfs_verify_change_attribute(struct inode *inode, unsigned long chattr)
  276. {
  277.     return !nfs_caches_unstable(inode)
  278.         && chattr == NFS_I(inode)->cache_change_attribute;
  279. }
  280.  
  281. /*
  282.  * linux/fs/nfs/inode.c
  283.  */
  284. extern void nfs_zap_caches(struct inode *);
  285. extern struct inode *nfs_fhget(struct super_block *, struct nfs_fh *,
  286.                 struct nfs_fattr *);
  287. extern int nfs_refresh_inode(struct inode *, struct nfs_fattr *);
  288. extern int nfs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
  289. extern int nfs_permission(struct inode *, int, struct nameidata *);
  290. extern int nfs_access_get_cached(struct inode *, struct rpc_cred *, struct nfs_access_entry *);
  291. extern void nfs_access_add_cache(struct inode *, struct nfs_access_entry *);
  292. extern int nfs_open(struct inode *, struct file *);
  293. extern int nfs_release(struct inode *, struct file *);
  294. extern int nfs_attribute_timeout(struct inode *inode);
  295. extern int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode);
  296. extern int __nfs_revalidate_inode(struct nfs_server *, struct inode *);
  297. extern int nfs_setattr(struct dentry *, struct iattr *);
  298. extern void nfs_begin_attr_update(struct inode *);
  299. extern void nfs_end_attr_update(struct inode *);
  300. extern void nfs_begin_data_update(struct inode *);
  301. extern void nfs_end_data_update(struct inode *);
  302. extern void nfs_end_data_update_defer(struct inode *);
  303. extern struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, struct rpc_cred *cred);
  304. extern struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx);
  305. extern void put_nfs_open_context(struct nfs_open_context *ctx);
  306. extern void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx);
  307. extern struct nfs_open_context *nfs_find_open_context(struct inode *inode, int mode);
  308. extern void nfs_file_clear_open_context(struct file *filp);
  309.  
  310. /* linux/net/ipv4/ipconfig.c: trims ip addr off front of name, too. */
  311. extern u32 root_nfs_parse_addr(char *name); /*__init*/
  312.  
  313. /*
  314.  * linux/fs/nfs/file.c
  315.  */
  316. extern struct inode_operations nfs_file_inode_operations;
  317. extern struct file_operations nfs_file_operations;
  318. extern struct address_space_operations nfs_file_aops;
  319.  
  320. static inline struct rpc_cred *nfs_file_cred(struct file *file)
  321. {
  322.     if (file != NULL) {
  323.         struct nfs_open_context *ctx;
  324.  
  325.         ctx = (struct nfs_open_context*)file->private_data;
  326.         return ctx->cred;
  327.     }
  328.     return NULL;
  329. }
  330.  
  331. /*
  332.  * linux/fs/nfs/direct.c
  333.  */
  334. extern ssize_t nfs_direct_IO(int, struct kiocb *, const struct iovec *, loff_t,
  335.             unsigned long);
  336. extern ssize_t nfs_file_direct_read(struct kiocb *iocb, char __user *buf,
  337.             size_t count, loff_t pos);
  338. extern ssize_t nfs_file_direct_write(struct kiocb *iocb, const char __user *buf,
  339.             size_t count, loff_t pos);
  340.  
  341. /*
  342.  * linux/fs/nfs/dir.c
  343.  */
  344. extern struct inode_operations nfs_dir_inode_operations;
  345. extern struct file_operations nfs_dir_operations;
  346. extern struct dentry_operations nfs_dentry_operations;
  347.  
  348. /*
  349.  * linux/fs/nfs/symlink.c
  350.  */
  351. extern struct inode_operations nfs_symlink_inode_operations;
  352.  
  353. /*
  354.  * linux/fs/nfs/locks.c
  355.  */
  356. extern int nfs_lock(struct file *, int, struct file_lock *);
  357.  
  358. /*
  359.  * linux/fs/nfs/unlink.c
  360.  */
  361. extern int  nfs_async_unlink(struct dentry *);
  362. extern void nfs_complete_unlink(struct dentry *);
  363.  
  364. /*
  365.  * linux/fs/nfs/write.c
  366.  */
  367. extern int  nfs_writepage(struct page *page, struct writeback_control *wbc);
  368. extern int  nfs_writepages(struct address_space *, struct writeback_control *);
  369. extern int  nfs_flush_incompatible(struct file *file, struct page *page);
  370. extern int  nfs_updatepage(struct file *, struct page *, unsigned int, unsigned int);
  371. extern void nfs_writeback_done(struct rpc_task *task);
  372.  
  373. #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
  374. extern void nfs_commit_done(struct rpc_task *);
  375. #endif
  376.  
  377. /*
  378.  * Try to write back everything synchronously (but check the
  379.  * return value!)
  380.  */
  381. extern int  nfs_sync_inode(struct inode *, unsigned long, unsigned int, int);
  382. extern int  nfs_flush_inode(struct inode *, unsigned long, unsigned int, int);
  383. extern int  nfs_flush_list(struct list_head *, int, int);
  384. #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
  385. extern int  nfs_commit_inode(struct inode *, unsigned long, unsigned int, int);
  386. extern int  nfs_commit_list(struct list_head *, int);
  387. #else
  388. static inline int
  389. nfs_commit_inode(struct inode *inode, unsigned long idx_start, unsigned int npages, int how)
  390. {
  391.     return 0;
  392. }
  393. #endif
  394.  
  395. static inline int
  396. nfs_have_writebacks(struct inode *inode)
  397. {
  398.     return NFS_I(inode)->npages != 0;
  399. }
  400.  
  401. static inline int
  402. nfs_wb_all(struct inode *inode)
  403. {
  404.     int error = nfs_sync_inode(inode, 0, 0, FLUSH_WAIT);
  405.     return (error < 0) ? error : 0;
  406. }
  407.  
  408. /*
  409.  * Write back all requests on one page - we do this before reading it.
  410.  */
  411. static inline int nfs_wb_page_priority(struct inode *inode, struct page* page, int how)
  412. {
  413.     int error = nfs_sync_inode(inode, page->index, 1,
  414.             how | FLUSH_WAIT | FLUSH_STABLE);
  415.     return (error < 0) ? error : 0;
  416. }
  417.  
  418. static inline int nfs_wb_page(struct inode *inode, struct page* page)
  419. {
  420.     return nfs_wb_page_priority(inode, page, 0);
  421. }
  422.  
  423. /*
  424.  * Allocate and free nfs_write_data structures
  425.  */
  426. extern mempool_t *nfs_wdata_mempool;
  427. extern mempool_t *nfs_commit_mempool;
  428.  
  429. static inline struct nfs_write_data *nfs_writedata_alloc(void)
  430. {
  431.     struct nfs_write_data *p = mempool_alloc(nfs_wdata_mempool, SLAB_NOFS);
  432.     if (p) {
  433.         memset(p, 0, sizeof(*p));
  434.         INIT_LIST_HEAD(&p->pages);
  435.     }
  436.     return p;
  437. }
  438.  
  439. static inline void nfs_writedata_free(struct nfs_write_data *p)
  440. {
  441.     mempool_free(p, nfs_wdata_mempool);
  442. }
  443.  
  444. extern void  nfs_writedata_release(struct rpc_task *task);
  445.  
  446. static inline struct nfs_write_data *nfs_commit_alloc(void)
  447. {
  448.     struct nfs_write_data *p = mempool_alloc(nfs_commit_mempool, SLAB_NOFS);
  449.     if (p) {
  450.         memset(p, 0, sizeof(*p));
  451.         INIT_LIST_HEAD(&p->pages);
  452.     }
  453.     return p;
  454. }
  455.  
  456. static inline void nfs_commit_free(struct nfs_write_data *p)
  457. {
  458.     mempool_free(p, nfs_commit_mempool);
  459. }
  460.  
  461. /* Hack for future NFS swap support */
  462. #ifndef IS_SWAPFILE
  463. # define IS_SWAPFILE(inode)    (0)
  464. #endif
  465.  
  466. /*
  467.  * linux/fs/nfs/read.c
  468.  */
  469. extern int  nfs_readpage(struct file *, struct page *);
  470. extern int  nfs_readpages(struct file *, struct address_space *,
  471.         struct list_head *, unsigned);
  472. extern int  nfs_pagein_list(struct list_head *, int);
  473. extern void nfs_readpage_result(struct rpc_task *);
  474.  
  475. /*
  476.  * Allocate and free nfs_read_data structures
  477.  */
  478. extern mempool_t *nfs_rdata_mempool;
  479.  
  480. static inline struct nfs_read_data *nfs_readdata_alloc(void)
  481. {
  482.     struct nfs_read_data *p = mempool_alloc(nfs_rdata_mempool, SLAB_NOFS);
  483.     if (p)
  484.         memset(p, 0, sizeof(*p));
  485.     return p;
  486. }
  487.  
  488. static inline void nfs_readdata_free(struct nfs_read_data *p)
  489. {
  490.     mempool_free(p, nfs_rdata_mempool);
  491. }
  492.  
  493. extern void  nfs_readdata_release(struct rpc_task *task);
  494.  
  495. /*
  496.  * linux/fs/mount_clnt.c
  497.  * (Used only by nfsroot module)
  498.  */
  499. extern int  nfsroot_mount(struct sockaddr_in *, char *, struct nfs_fh *,
  500.         int, int);
  501.  
  502. /*
  503.  * inline functions
  504.  */
  505.  
  506. static inline loff_t
  507. nfs_size_to_loff_t(__u64 size)
  508. {
  509.     loff_t maxsz = (((loff_t) ULONG_MAX) << PAGE_CACHE_SHIFT) + PAGE_CACHE_SIZE - 1;
  510.     if (size > maxsz)
  511.         return maxsz;
  512.     return (loff_t) size;
  513. }
  514.  
  515. static inline ino_t
  516. nfs_fileid_to_ino_t(u64 fileid)
  517. {
  518.     ino_t ino = (ino_t) fileid;
  519.     if (sizeof(ino_t) < sizeof(u64))
  520.         ino ^= fileid >> (sizeof(u64)-sizeof(ino_t)) * 8;
  521.     return ino;
  522. }
  523.  
  524. /* NFS root */
  525.  
  526. extern void * nfs_root_data(void);
  527.  
  528. #define nfs_wait_event(clnt, wq, condition)                \
  529. ({                                    \
  530.     int __retval = 0;                        \
  531.     if (clnt->cl_intr) {                        \
  532.         sigset_t oldmask;                    \
  533.         rpc_clnt_sigmask(clnt, &oldmask);            \
  534.         __retval = wait_event_interruptible(wq, condition);    \
  535.         rpc_clnt_sigunmask(clnt, &oldmask);            \
  536.     } else                                \
  537.         wait_event(wq, condition);                \
  538.     __retval;                            \
  539. })
  540.  
  541. #define NFS_JUKEBOX_RETRY_TIME (5 * HZ)
  542.  
  543. #ifdef CONFIG_NFS_V4
  544.  
  545. struct idmap;
  546.  
  547. /*
  548.  * In a seqid-mutating op, this macro controls which error return
  549.  * values trigger incrementation of the seqid.
  550.  *
  551.  * from rfc 3010:
  552.  * The client MUST monotonically increment the sequence number for the
  553.  * CLOSE, LOCK, LOCKU, OPEN, OPEN_CONFIRM, and OPEN_DOWNGRADE
  554.  * operations.  This is true even in the event that the previous
  555.  * operation that used the sequence number received an error.  The only
  556.  * exception to this rule is if the previous operation received one of
  557.  * the following errors: NFSERR_STALE_CLIENTID, NFSERR_STALE_STATEID,
  558.  * NFSERR_BAD_STATEID, NFSERR_BAD_SEQID, NFSERR_BADXDR,
  559.  * NFSERR_RESOURCE, NFSERR_NOFILEHANDLE.
  560.  *
  561.  */
  562. #define seqid_mutating_err(err)       \
  563. (((err) != NFSERR_STALE_CLIENTID) &&  \
  564.  ((err) != NFSERR_STALE_STATEID)  &&  \
  565.  ((err) != NFSERR_BAD_STATEID)    &&  \
  566.  ((err) != NFSERR_BAD_SEQID)      &&  \
  567.  ((err) != NFSERR_BAD_XDR)        &&  \
  568.  ((err) != NFSERR_RESOURCE)       &&  \
  569.  ((err) != NFSERR_NOFILEHANDLE))
  570.  
  571. enum nfs4_client_state {
  572.     NFS4CLNT_OK  = 0,
  573. };
  574.  
  575. /*
  576.  * The nfs4_client identifies our client state to the server.
  577.  */
  578. struct nfs4_client {
  579.     struct list_head    cl_servers;    /* Global list of servers */
  580.     struct in_addr        cl_addr;    /* Server identifier */
  581.     u64            cl_clientid;    /* constant */
  582.     nfs4_verifier        cl_confirm;
  583.     unsigned long        cl_state;
  584.  
  585.     u32            cl_lockowner_id;
  586.  
  587.     /*
  588.      * The following rwsem ensures exclusive access to the server
  589.      * while we recover the state following a lease expiration.
  590.      */
  591.     struct rw_semaphore    cl_sem;
  592.  
  593.     struct list_head    cl_delegations;
  594.     struct list_head    cl_state_owners;
  595.     struct list_head    cl_unused;
  596.     int            cl_nunused;
  597.     spinlock_t        cl_lock;
  598.     atomic_t        cl_count;
  599.  
  600.     struct rpc_clnt *    cl_rpcclient;
  601.     struct rpc_cred *    cl_cred;
  602.  
  603.     struct list_head    cl_superblocks;    /* List of nfs_server structs */
  604.  
  605.     unsigned long        cl_lease_time;
  606.     unsigned long        cl_last_renewal;
  607.     struct work_struct    cl_renewd;
  608.     struct work_struct    cl_recoverd;
  609.  
  610.     wait_queue_head_t    cl_waitq;
  611.     struct rpc_wait_queue    cl_rpcwaitq;
  612.  
  613.     /* idmapper */
  614.     struct idmap *        cl_idmap;
  615.  
  616.     /* Our own IP address, as a null-terminated string.
  617.      * This is used to generate the clientid, and the callback address.
  618.      */
  619.     char            cl_ipaddr[16];
  620. };
  621.  
  622. /*
  623.  * NFS4 state_owners and lock_owners are simply labels for ordered
  624.  * sequences of RPC calls. Their sole purpose is to provide once-only
  625.  * semantics by allowing the server to identify replayed requests.
  626.  *
  627.  * The ->so_sema is held during all state_owner seqid-mutating operations:
  628.  * OPEN, OPEN_DOWNGRADE, and CLOSE. Its purpose is to properly serialize
  629.  * so_seqid.
  630.  */
  631. struct nfs4_state_owner {
  632.     struct list_head     so_list;     /* per-clientid list of state_owners */
  633.     struct nfs4_client   *so_client;
  634.     u32                  so_id;      /* 32-bit identifier, unique */
  635.     struct semaphore     so_sema;
  636.     u32                  so_seqid;   /* protected by so_sema */
  637.     atomic_t         so_count;
  638.  
  639.     struct rpc_cred         *so_cred;     /* Associated cred */
  640.     struct list_head     so_states;
  641.     struct list_head     so_delegations;
  642. };
  643.  
  644. /*
  645.  * struct nfs4_state maintains the client-side state for a given
  646.  * (state_owner,inode) tuple (OPEN) or state_owner (LOCK).
  647.  *
  648.  * OPEN:
  649.  * In order to know when to OPEN_DOWNGRADE or CLOSE the state on the server,
  650.  * we need to know how many files are open for reading or writing on a
  651.  * given inode. This information too is stored here.
  652.  *
  653.  * LOCK: one nfs4_state (LOCK) to hold the lock stateid nfs4_state(OPEN)
  654.  */
  655.  
  656. struct nfs4_lock_state {
  657.     struct list_head    ls_locks;    /* Other lock stateids */
  658.     fl_owner_t        ls_owner;    /* POSIX lock owner */
  659. #define NFS_LOCK_INITIALIZED 1
  660.     int            ls_flags;
  661.     u32            ls_seqid;
  662.     u32            ls_id;
  663.     nfs4_stateid        ls_stateid;
  664.     atomic_t        ls_count;
  665. };
  666.  
  667. /* bits for nfs4_state->flags */
  668. enum {
  669.     LK_STATE_IN_USE,
  670.     NFS_DELEGATED_STATE,
  671. };
  672.  
  673. struct nfs4_state {
  674.     struct list_head open_states;    /* List of states for the same state_owner */
  675.     struct list_head inode_states;    /* List of states for the same inode */
  676.     struct list_head lock_states;    /* List of subservient lock stateids */
  677.  
  678.     struct nfs4_state_owner *owner;    /* Pointer to the open owner */
  679.     struct inode *inode;        /* Pointer to the inode */
  680.  
  681.     unsigned long flags;        /* Do we hold any locks? */
  682.     struct semaphore lock_sema;    /* Serializes file locking operations */
  683.     rwlock_t state_lock;        /* Protects the lock_states list */
  684.  
  685.     nfs4_stateid stateid;
  686.  
  687.     unsigned int nreaders;
  688.     unsigned int nwriters;
  689.     int state;            /* State on the server (R,W, or RW) */
  690.     atomic_t count;
  691. };
  692.  
  693.  
  694. struct nfs4_exception {
  695.     long timeout;
  696.     int retry;
  697. };
  698.  
  699. extern struct dentry_operations nfs4_dentry_operations;
  700. extern struct inode_operations nfs4_dir_inode_operations;
  701.  
  702. /* nfs4proc.c */
  703. extern int nfs4_proc_setclientid(struct nfs4_client *, u32, unsigned short);
  704. extern int nfs4_proc_setclientid_confirm(struct nfs4_client *);
  705. extern int nfs4_open_reclaim(struct nfs4_state_owner *, struct nfs4_state *);
  706. extern int nfs4_proc_async_renew(struct nfs4_client *);
  707. extern int nfs4_proc_renew(struct nfs4_client *);
  708. extern int nfs4_do_close(struct inode *inode, struct nfs4_state *state, mode_t mode);
  709. extern int nfs4_wait_clnt_recover(struct rpc_clnt *, struct nfs4_client *);
  710. extern struct inode *nfs4_atomic_open(struct inode *, struct dentry *, struct nameidata *);
  711. extern int nfs4_open_revalidate(struct inode *, struct dentry *, int);
  712. extern int nfs4_handle_exception(struct nfs_server *, int, struct nfs4_exception *);
  713. extern int nfs4_lock_reclaim(struct nfs4_state *state, struct file_lock *request);
  714.  
  715. /* nfs4renewd.c */
  716. extern void nfs4_schedule_state_renewal(struct nfs4_client *);
  717. extern void nfs4_renewd_prepare_shutdown(struct nfs_server *);
  718. extern void nfs4_kill_renewd(struct nfs4_client *);
  719.  
  720. /* nfs4state.c */
  721. extern void init_nfsv4_state(struct nfs_server *);
  722. extern void destroy_nfsv4_state(struct nfs_server *);
  723. extern struct nfs4_client *nfs4_get_client(struct in_addr *);
  724. extern void nfs4_put_client(struct nfs4_client *clp);
  725. extern int nfs4_init_client(struct nfs4_client *clp);
  726. extern struct nfs4_client *nfs4_find_client(struct in_addr *);
  727. extern u32 nfs4_alloc_lockowner_id(struct nfs4_client *);
  728.  
  729. extern struct nfs4_state_owner * nfs4_get_state_owner(struct nfs_server *, struct rpc_cred *);
  730. extern void nfs4_put_state_owner(struct nfs4_state_owner *);
  731. extern struct nfs4_state * nfs4_get_open_state(struct inode *, struct nfs4_state_owner *);
  732. extern void nfs4_put_open_state(struct nfs4_state *);
  733. extern void nfs4_close_state(struct nfs4_state *, mode_t);
  734. extern struct nfs4_state *nfs4_find_state(struct inode *, struct rpc_cred *, mode_t mode);
  735. extern void nfs4_increment_seqid(int status, struct nfs4_state_owner *sp);
  736. extern void nfs4_schedule_state_recovery(struct nfs4_client *);
  737. extern struct nfs4_lock_state *nfs4_find_lock_state(struct nfs4_state *state, fl_owner_t);
  738. extern struct nfs4_lock_state *nfs4_get_lock_state(struct nfs4_state *state, fl_owner_t);
  739. extern void nfs4_put_lock_state(struct nfs4_lock_state *state);
  740. extern void nfs4_increment_lock_seqid(int status, struct nfs4_lock_state *ls);
  741. extern void nfs4_notify_setlk(struct nfs4_state *, struct file_lock *, struct nfs4_lock_state *);
  742. extern void nfs4_notify_unlck(struct nfs4_state *, struct file_lock *, struct nfs4_lock_state *);
  743. extern void nfs4_copy_stateid(nfs4_stateid *, struct nfs4_state *, fl_owner_t);
  744.  
  745.  
  746.  
  747. struct nfs4_mount_data;
  748. #else
  749. #define init_nfsv4_state(server)  do { } while (0)
  750. #define destroy_nfsv4_state(server)       do { } while (0)
  751. #define nfs4_put_state_owner(inode, owner) do { } while (0)
  752. #define nfs4_put_open_state(state) do { } while (0)
  753. #define nfs4_close_state(a, b) do { } while (0)
  754. #define nfs4_renewd_prepare_shutdown(server) do { } while (0)
  755. #endif
  756.  
  757. #endif /* __KERNEL__ */
  758.  
  759. /*
  760.  * NFS debug flags
  761.  */
  762. #define NFSDBG_VFS        0x0001
  763. #define NFSDBG_DIRCACHE        0x0002
  764. #define NFSDBG_LOOKUPCACHE    0x0004
  765. #define NFSDBG_PAGECACHE    0x0008
  766. #define NFSDBG_PROC        0x0010
  767. #define NFSDBG_XDR        0x0020
  768. #define NFSDBG_FILE        0x0040
  769. #define NFSDBG_ROOT        0x0080
  770. #define NFSDBG_CALLBACK        0x0100
  771. #define NFSDBG_ALL        0xFFFF
  772.  
  773. #ifdef __KERNEL__
  774. # undef ifdebug
  775. # ifdef NFS_DEBUG
  776. #  define ifdebug(fac)        if (unlikely(nfs_debug & NFSDBG_##fac))
  777. # else
  778. #  define ifdebug(fac)        if (0)
  779. # endif
  780. #endif /* __KERNEL */
  781.  
  782. #endif
  783.